home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Texteditors / XDME / include / prog-protos.h < prev    next >
Encoding:
Text File  |  1996-09-27  |  22.9 KB  |  529 lines
  1. Prototype void          do_iconify        (void);
  2. Prototype void          iconify        (void);
  3. Prototype void          uniconify        (void);
  4. Prototype void          do_newwindow        (void);
  5. Prototype void          do_openwindow     (void);
  6. Prototype struct Window * TOpenWindow        (struct NewWindow *);
  7. Prototype struct Window * opensharedwindow  (struct NewWindow *);
  8. Prototype void          closesharedwindow (struct Window *);
  9. Prototype int          getyn         (char *, char *, char *, ...);
  10. Prototype void          title         (char *, ...);
  11. Prototype void          window_title        (void);
  12. Prototype void          set_window_params (void);
  13. Prototype void          do_resize        (void);
  14. Prototype char        * geoskip        (char *, int *, int *);
  15. Prototype void          prop_adj        (void);
  16. Prototype struct PropGadget * add_prop        (struct Window *);
  17. Prototype void          free_prop        (struct PropGadget *);
  18. Prototype void          rem_prop        (ED *);
  19. Prototype void          rest_prop        (ED *);
  20. Prototype ULONG       new_top        (void);
  21. Prototype void          GeometryToNW        (char *, struct NewWindow *);
  22. Prototype void          do_title        (void);
  23. Prototype void          do_showlog        (void);
  24. Prototype void          error         (char *, ...);
  25. Prototype void          warn            (char *, ...);
  26. Prototype void          do_setgeometry    (void);
  27. Prototype void          do_toback        (void);
  28. Prototype void          do_tofront        (void);
  29. Prototype void show_title (char *);
  30. Prototype ED    * uninit_init         (ED *);
  31. Prototype int      setpen         (Line, Column);
  32. Prototype WORD      inversemode         (int);
  33. Prototype void      text_cursor         (int);
  34. Prototype int      text_init         (ED *, WIN *, struct NewWindow *);
  35. Prototype BOOL      text_switch         (struct Window *);
  36. Prototype BOOL      text_sync         (void);
  37. Prototype BOOL      text_adjust         (BOOL);
  38. Prototype void      text_load         (void);
  39. Prototype int      text_colno         (void);
  40. Prototype int      text_lineno         (void);
  41. Prototype int      text_lines         (void);
  42. Prototype int      text_cols         (void);
  43. Prototype int      text_imode         (void);
  44. Prototype int      text_tabsize         (void);
  45. Prototype UBYTE * text_name         (void);
  46. Prototype void      text_uninit         (void);
  47. Prototype void      text_position      (int, int);
  48. Prototype void      text_redisplaycurrline (void);
  49. Prototype void      do_redisplay         (void);
  50. Prototype void      text_redisplay     (void);
  51. Prototype void      text_write         (UBYTE *);
  52. Prototype void      text_displayseg     (int, int);
  53. Prototype void      text_redraw_cmdline     (void);
  54. Prototype void      text_redrawblock     (BOOL);
  55. Prototype void      redraw_text         (Line, Line);
  56. Prototype void      redraw_textlineseg     (Line, Column, Column);
  57. Prototype void      redraw_lineseg     (UBYTE *, UWORD, Column, Column);
  58. Prototype void     redraw_block        (BOOL, Line, Column, Line, Column);
  59. Prototype int  main      (int, char **);
  60. Prototype void do_tomouse (void);
  61. Prototype void exiterr      (char *);
  62. Prototype int  breakcheck (void);
  63. Prototype void breakreset (void);
  64. Prototype void ops      (char **);
  65. Prototype BOOL loadfile   (BPTR, char *);
  66. Prototype struct MsgPort  * Sharedport;
  67. Prototype char            MShowTitle;
  68. Prototype char            noadj;
  69. Prototype struct GfxBase  * GfxBase;
  70. Prototype struct __XDMEArgs XDMEArgs;
  71. Prototype void OptimizedRefresh (ED *);
  72. Prototype void do_bs         (void);
  73. Prototype void do_del         (void);
  74. Prototype void do_remeol     (void);
  75. Prototype void do_split      (void);
  76. Prototype int  do_join         (void);
  77. Prototype void do_reformat   (int);
  78. Prototype void do_insertmode (void);
  79. Prototype void do_insline    (void);
  80. Prototype void do_deline     (void);
  81. Prototype void do_tlate      (void);
  82. Prototype void do_justify    (void);
  83. Prototype void do_unjustify  (void);
  84. Prototype void do_indent     (void);
  85. Prototype void do_inslines   (void);
  86. Prototype void do_delete     (void);
  87. Prototype void do_delines    (void);
  88. Prototype void do_undeline   (void);
  89. Prototype void do_space      (void);
  90. Prototype void do_clipins    (void);
  91. Prototype void do_return     (void);
  92. Prototype void do_up              (void);
  93. Prototype void do_scrolldown          (void);
  94. Prototype void do_scrollup          (void);
  95. Prototype void do_down              (void);
  96. Prototype void do_page              (void);
  97. Prototype void do_downadd          (void);
  98. Prototype void do_left              (void);
  99. Prototype void do_right           (void);
  100. Prototype void do_tab              (void);
  101. Prototype void do_backtab          (void);
  102. Prototype void do_top              (void);
  103. Prototype void do_bottom          (void);
  104. Prototype void do_firstcolumn          (void);
  105. Prototype void do_firstnb          (void);
  106. Prototype void do_lastcolumn          (void);
  107. Prototype void do_goto              (void);
  108. Prototype void do_screentop          (void);
  109. Prototype void do_screenbottom          (void);
  110. Prototype void do_wleft           (void);
  111. Prototype void do_wright          (void);
  112. Prototype void do_col              (void);
  113. Prototype void do_scroll          (int);
  114. Prototype void do_match           (void);
  115. Prototype void do_ping              (void);
  116. Prototype void do_pong              (void);
  117. Prototype void do_undo              (void);
  118. Prototype int  get_pong           (int);
  119. Prototype void escapecomlinemode      (void);
  120. Prototype void do_esc              (void);
  121. Prototype void do_recall          (void);
  122. Prototype void markerkill          (ED *);
  123. Prototype char    * HistoBuff[];
  124. Prototype WORD      NumHistoLines;
  125. Prototype WORD      HistoLine;
  126. Prototype int get_char (ED * ep, struct pos * curr, int dir);
  127. Prototype void do_if        (void);
  128. Prototype void do_repeat    (void);
  129. Prototype int  do_toggle    (int);
  130. Prototype void do_scanf     (void);
  131. Prototype void do_push        (void);
  132. Prototype void do_pop        (void);
  133. Prototype void do_swap        (void);
  134. Prototype void check_stack  (ED *);
  135. Prototype void path_init   (void);
  136. Prototype void do_addpath  (void);
  137. Prototype void do_rempath  (void);
  138. Prototype void do_refctags (void);
  139. Prototype void do_ctags    (void);
  140. Prototype void do_refs       (void);
  141. Prototype int searchref    (char *, char *, char **, char **, long *, char **);
  142. Prototype int dirpart       (char *);
  143. Prototype LIST PBase;
  144. Prototype int     do_command   (char *);
  145. Prototype void     do_null      (void);
  146. Prototype void     do_source    (long);
  147. Prototype void     do_quit      (void);
  148. Prototype void     do_quitall   (void);
  149. Prototype void     do_execute   (void);
  150. Prototype char * breakout     (char **, char *, char **);
  151. Prototype void     makemygadget     (struct Gadget *);
  152. Prototype int     firstns     (char *);
  153. Prototype int     lastns      (char *);
  154. Prototype int     wordlen     (char *);
  155. Prototype BOOL     getpathto     (BPTR, char *, char *);
  156. Prototype LINE     allocline     (long);
  157. Prototype int     detab         (char *, char *, int);
  158. Prototype int     xefgets     (FILE *, char *, int);
  159. Prototype ED   * finded      (char *, int);
  160. Prototype void     mountrequest     (int);
  161. Prototype FONT * GetFont     (char *, WORD);
  162. Prototype void     freeline     (LINE);
  163. Prototype void     movetocursor     (void);
  164. Prototype int     extend      (ED *, int);
  165. Prototype int     makeroom     (int);
  166. Prototype void     freelist     (LINE *, int);
  167. Prototype long     lineflags     (int);
  168. Prototype void     scroll_display  (WORD, WORD , Column, Line, Column, Line);
  169. Prototype char * skip_whitespace (char *);
  170. Prototype char     is_number     (char *);
  171. Prototype char * getnextcomline  (FILE *, int *);
  172. Prototype char * fname         (char *);
  173. Prototype BOOL     switch_ed     (ED *);
  174. Prototype void     do_makecursorvisible (void);
  175. Prototype void     MakeRectVisible (WIN *, UWORD, UWORD, UWORD, UWORD);
  176. Prototype int     LINELEN     (ED *, Line);
  177. Prototype void swapmem (void *, void *, ULONG);
  178. Prototype void * currentmenu  (void); /* muss neu besetzt werden bei jeder Veraenderung des aktuellen Textes */
  179. Prototype void * currenthash  (void); /* muss neu besetzt werden bei jeder Veraenderung des aktuellen Textes */
  180. Prototype void * currentwindow(void); /* muss neu besetzt werden bei jeder Veraenderung des aktuellen Textes */
  181. Prototype void     init_structures (void);
  182. Prototype void do_findstr    (void);
  183. Prototype void do_findr     (void);
  184. Prototype void do_find        (void);
  185. Prototype void do_replace    (void);
  186. Prototype void search_operation (void);
  187. Prototype void do_margin      (void);
  188. Prototype void do_wordwrap      (void);
  189. Prototype void do_global      (void);
  190. Prototype void do_setparcol      (void);
  191. Prototype void do_tabstop      (void);
  192. Prototype void do_chfilename      (void);
  193. Prototype void do_savetabs      (void);
  194. Prototype void do_setfont      (void);
  195. Prototype void do_ignorecase      (void);
  196. Prototype void loadconfig      (ED *);
  197. Prototype void do_saveconfig      (void);
  198. Prototype void do_fgpen       (void);
  199. Prototype void do_bgpen       (void);
  200. Prototype void do_hgpen       (void);
  201. Prototype void do_bbpen       (void);
  202. Prototype void do_tpen          (void);
  203. Prototype void do_modified      (void);
  204. Prototype void do_autoindent      (void);
  205. Prototype void do_sizewindow      (void);
  206. Prototype void do_autosplit      (void);
  207. Prototype void do_taskpri      (void);
  208. Prototype void do_debug       (void);
  209. Prototype void do_autounblock      (void);
  210. Prototype void do_followcursor      (void);
  211. Prototype void do_setlinedistance (void);
  212. Prototype APTR     AllocFunc  (long, long);
  213. Prototype void     FreeFunc   (APTR, long);
  214. Prototype void     DeallocFunc(char *);
  215. Prototype char * DupFunc    (char *, long);
  216. Prototype int  do_edit         (void);
  217. Prototype int  do_bappendsave(void);
  218. Prototype int  do_bsave      (void);
  219. Prototype int  do_barpsave   (void);
  220. Prototype int  do_appendsave (void);
  221. Prototype int  do_save         (void);
  222. Prototype int  do_saveas     (void);
  223. Prototype int  do_aslsave    (void);
  224. Prototype int  do_reqsave    (void);
  225. Prototype int  saveit         (const char *);
  226. Prototype void do_cd         (void);
  227. Prototype int do_writeto (void);
  228. Prototype ULONG            OpenRexx         (char *, const char *, __stkargs void (*do_res)(struct RexxMsg *), BPTR, BPTR);
  229. Prototype BOOL               CloseRexx        (void);
  230. Prototype long               LastRexxError        (void);
  231. Prototype struct RexxMsg     * BuildRexxMsg        (const char *, const long, char *, ...);
  232. Prototype BOOL               RemoveRexxMsg        (struct RexxMsg *);
  233. Prototype BOOL               PutRexxMsg        (char *, struct RexxMsg *);
  234. Prototype struct RexxMsg     * GetRexxMsg        (void);
  235. Prototype struct RexxMsg     * FetchRexxMsg        (void);
  236. Prototype BOOL               ReplyRexxMsg        (struct RexxMsg *, long, char *);
  237. Prototype long               SyncRexxCommand        (const char *, const char *, char *, long, char *, ...);
  238. Prototype __stkargs void       RexxMessageHandler   (struct RexxMsg *);
  239. Prototype void             * ChangeProcessMessage (__stkargs void (*new_func)(struct RexxMsg *));
  240. Prototype struct RexxCommand * SetRexxCommandTable  (struct RexxCommand *);
  241. Prototype long               ModifyRepCount        (long);
  242. Prototype BOOL               AttempCloseRexx        (void);
  243. Prototype LIST        DBase;
  244. Prototype ED      * Ep;
  245. Prototype struct Config default_config;
  246. Prototype struct GlobalFlags globalflags;
  247. Prototype long        Nsu;
  248. Prototype UBYTE     CtlC;
  249. Prototype UBYTE     Current[MAXLINELEN];
  250. Prototype UBYTE     Deline[MAXLINELEN];
  251. Prototype UBYTE     Space[32];
  252. Prototype Column    Clen;
  253. Prototype UBYTE   * Partial;
  254. Prototype UBYTE   * esc_partial;
  255. Prototype UBYTE   * String;
  256. Prototype Block     ActualBlock;
  257. Prototype UWORD     ColumnPos[MAXLINELEN];
  258. Prototype UWORD     RowPos[MAXROWS];
  259. Prototype UWORD     Xsize;
  260. Prototype UWORD     Ysize;
  261. Prototype UWORD     XTbase;
  262. Prototype UWORD     YTbase;
  263. Prototype UWORD     Lines;
  264. Prototype UWORD     Columns;
  265. Prototype UWORD     Xbase;
  266. Prototype UWORD     Ybase;
  267. Prototype UWORD     Xpixs;
  268. Prototype UWORD     Ypixs;
  269. Prototype UWORD     LineDistance;
  270. Prototype UBYTE   * av[];
  271. Prototype WORD        PageJump;
  272. Prototype UBYTE     RexxPortName[8];
  273. Prototype UBYTE     tmp_buffer[256];
  274. Prototype UWORD     NumClicks;
  275. Prototype ULONG     LoopCont;
  276. Prototype ULONG     LoopBreak;
  277. Prototype ULONG     MacroRecord;
  278. Prototype const UBYTE *version; /* PATCH_NULL 27-07-94 */
  279. Prototype struct IntuitionBase * IntuitionBase;
  280. Prototype struct GfxBase       * GfxBase;
  281. Prototype struct Library       * IconBase;
  282. Prototype struct Library       * AslBase;
  283. Prototype struct DosLibrary    * DOSBase;
  284. Prototype struct WBStartup     * Wbs;
  285. Prototype void do_pattern    (void);
  286. Prototype void do_aslload    (void);
  287. Prototype int  aslsave         (void);
  288. Prototype void do_aslinsfile (void);
  289. Prototype void do_aslfont    (void);
  290. Prototype void do_reqload    (void);
  291. Prototype int  reqsave         (void);
  292. Prototype void do_reqinsfile (void);
  293. Prototype void do_reqfont    (void);
  294. Prototype void splitpath     (char *, char *, char *);
  295. Prototype void fixdirname    (char *);
  296. Prototype struct FileRequester     * FReq;
  297. Prototype struct ReqToolsBase     * ReqToolsBase;
  298. Prototype struct rtFileRequester * RFReq;
  299. Prototype ULONG RexxMask;
  300. Prototype int foundcmd; /* control for implicit ARexx macro invocation     */
  301. Prototype int cmderr;    /* global command error flag for do_rexx()'s use */
  302. Prototype void     openrexx         (void);
  303. Prototype void     closerexx         (void);
  304. Prototype void     do_rx             (void);
  305. Prototype void     do_rx1          (void);
  306. Prototype void     do_rx2          (void);
  307. Prototype long     do_rxImplied         (char *, char *);
  308. Prototype void     extern_rexx_command (void);
  309. Prototype void     to_port         (void);
  310. Prototype void     select_window         (void);
  311. Prototype void     project_info         (void);
  312. Prototype int     load_project         (void);
  313. Prototype void     save_project         (void);
  314. Prototype void     put_rexx_result     (void);
  315. Prototype char * get_rexx_result     (void);
  316. Prototype long     do_rexx         (const char * port, const char *fmt, ...);
  317. Prototype UWORD  is_inblock     (Line, Column);
  318. Prototype void     displayblock     (BOOL);
  319. Prototype void     redraw_block     (BOOL, Line, Column, Line, Column);
  320. Prototype void     do_blocktype     (void);
  321. Prototype void     do_block     (void);
  322. Prototype BOOL     block_ok     (void);
  323. Prototype void     do_copy     (void);
  324. Prototype char * block_to_string (void);
  325. Prototype void     do_bdelete     (void);
  326. Prototype void     do_bcopy     (void);
  327. Prototype void     do_bmove     (void);
  328. Prototype void     do_bsource     (void);
  329. Prototype void set_pubscreen (void);
  330. Prototype void        init_variables  (void);
  331. Prototype char *    GetTypedVar     (char *, int *);
  332. Prototype void        SetTypedVar     (char *, char *, int);
  333. Prototype void        do_set        (void);
  334. Prototype void        do_unset        (void);
  335. Prototype void        do_setenv        (void);
  336. Prototype void        do_unsetenv     (void);
  337. Prototype void        do_settvar        (void);
  338. Prototype void        do_unsettvar    (void);
  339. Prototype int        is_tflagset     (int);              /* Proto'd for access from control.c */
  340. Prototype int        is_gflagset     (int);              /* Proto'd for access from control.c */
  341. Prototype void        do_flag        (void);
  342. Prototype void        do_toggleflag   (void);
  343. Prototype char *    getvar        (char *);
  344. Prototype char* GetSpecialVar (char* Name);
  345. Prototype char* GetSpecialInt (char* Name);
  346. Prototype char* GetSpecialFlag(char* Name);
  347. Prototype char SetSpecialFlag(char* Name, char* Value);
  348. Prototype char SetSpecialInt (char* Name, char* Value);
  349. Prototype char SetSpecialVar (char* Name, char* Value);
  350. Prototype void do_togglespecialflag(void);
  351. Prototype void do_setspecialvar(void);
  352. Prototype char* current_word (void);
  353. Prototype void do_pushVAR  (void);
  354. Prototype void do_pickVAR  (void);
  355. Prototype void do_popVAR   (void);
  356. Prototype void do_swapVAR  (void);
  357. Prototype void do_purgeVAR (void);
  358. Prototype void     DelAllVarsFromTree ( VBASE * tree );
  359. Prototype void     DelVarFromTree     ( VBASE * tree, char * name );
  360. Prototype char * GetVarFromTree     ( VBASE * tree, char * name );
  361. Prototype void     SetVarIntoTree     ( VBASE * tree, char * name, char * value );
  362. Prototype char* names2string   ( MLIST* list, char* buffer, char delimiter, void* filter );  /* assumes buffer is 1/4k * BUFFERS chgars long */
  363. Prototype int    numnodes       ( MLIST* list );
  364. Prototype NODE* findnode       ( MLIST* list, char* name, short len );
  365. Prototype void    DelAllVarsFromList ( MLIST* list );
  366. Prototype void    DelVarFromList ( MLIST* list, char* name );
  367. Prototype char* GetVarFromList ( MLIST* list, char* name );
  368. Prototype void    SetVarIntoList ( MLIST* list, char* name, char* value );
  369. Prototype int     test_arg  (char*, int);
  370. Prototype char * GetFlag   (char*, char*, int, char*);
  371. Prototype char     SetFlag   (char*, char*, char*, int, char*);
  372. Prototype int     IsFlagSet (char*, int, int);
  373. Prototype void do_delmenu   (void);
  374. Prototype void do_delitem   (void);
  375. Prototype void do_delitembar(void);
  376. Prototype void do_delsub    (void);
  377. Prototype void do_delsubbar (void);
  378. Prototype void do_itembar   (void);
  379. Prototype void do_itemcheck (void);
  380. Prototype void do_itemadd   (void);
  381. Prototype void do_subadd    (void);
  382. Prototype void do_subcheck  (void);
  383. Prototype void do_subbar    (void);
  384. Prototype void do_menuoff   (void);
  385. Prototype void do_menuon    (void);
  386. Prototype void do_menuload  (void);
  387. Prototype void do_menusave  (void);
  388. Prototype char*menutomacro  (char*);
  389. Prototype void do_menuclear (void);
  390. Prototype void do_getcheckitem (void);
  391. Prototype void do_getchecksub  (void);
  392. Prototype void do_setcheckitem (void);
  393. Prototype void do_setchecksub  (void);
  394. Prototype void do_new_menustrip (void);
  395. Prototype void do_del_menustrip (void);
  396. Prototype void do_use_menustrip (void);
  397. Prototype APTR menufind (char *name);
  398. Prototype char *menugethelp(APTR handle);
  399. Prototype char *menugetcommand(APTR handle);
  400. Prototype char *menusetcommand(APTR handle, char *val);
  401. Prototype char *menusethelp (APTR handle, char *val);
  402. Prototype int menucall (APTR handle);
  403. Prototype void        menuclear   (MENUSTRIP *ms);
  404. Prototype int        menudel     (MENUSTRIP *ms, char *tname);
  405. Prototype int        itemdel     (MENUSTRIP *ms, char *tname, char *iname);
  406. Prototype int        subdel        (MENUSTRIP *ms, char *tname, char *iname, char *sname);
  407. Prototype XITEM *    itemadd     (MENUSTRIP *ms, char *tname, char *iname,              char *macro, char *help, int check, char *scut);
  408. Prototype XITEM *    subadd        (MENUSTRIP *ms, char *tname, char *iname, char *sname, char *macro, char *help, int check, char *scut);
  409. Prototype int        loadmenus   (MENUSTRIP *ms, FILE *fi,     int *lineno);
  410. Prototype int        savemenus   (MENUSTRIP *ms, FILE *fo);
  411. Prototype int        chkitemcheck(MENUSTRIP *ms, char *tname, char *iname);
  412. Prototype int        chksubcheck (MENUSTRIP *ms, char *tname, char *iname, char *sname);
  413. Prototype int        setitemcheck(MENUSTRIP *ms, char *tname, char *iname,              int status);
  414. Prototype int        setsubcheck (MENUSTRIP *ms, char *tname, char *iname, char *sname, int status);
  415. Prototype APTR        menu2macro  (MENUSTRIP *ms, char *str);
  416. Prototype MENUSTRIP *get_menustrip    (char * name);
  417. Prototype MENUSTRIP *new_menustrip    (char * name, int defaults);
  418. Prototype void         delete_menustrip (MENUSTRIP * kt, int force);
  419. Prototype void         exit_menustrips (void);
  420. Prototype APTR menu_cmd (struct IntuiMessage * im);
  421. Prototype void    menuon         (MENUSTRIP * ms, struct Window * win);
  422. Prototype void    menuoff      (MENUSTRIP * ms, struct Window * win);
  423. Prototype void    menu_strip   (MENUSTRIP * ms, struct Window * Win);
  424. Prototype void    menuload     (MENUSTRIP * ms,  char * fname);
  425. Prototype void    menusave     (MENUSTRIP * ms,  char * fname);
  426. Prototype void    fixmenu      (MENUSTRIP * ms, struct Window * win);
  427. Prototype void* currentmenu  (void);
  428. Prototype void* currentwindow(void);
  429. Prototype void do_map        (void);
  430. Prototype void do_unmap     (void);
  431. Prototype void do_keyload   (void);
  432. Prototype void do_keysave   (void);
  433. Prototype void do_qualifier (void);
  434. Prototype char*keyspectomacro(char*);
  435. Prototype void do_new_keytable (void);
  436. Prototype void do_del_keytable (void);
  437. Prototype void do_use_keytable (void);
  438. Prototype void*currenthash  (void);
  439. Prototype APTR keyfind (char *name);
  440. Prototype char *keygethelp(APTR handle);
  441. Prototype char *keygetcommand(APTR handle);
  442. Prototype char *keysetcommand(APTR handle, char *val);
  443. Prototype char *keysethelp (APTR handle, char *val);
  444. Prototype int keycall (APTR handle);
  445. Prototype void     keyload    (KEYTABLE * kt, char * name);
  446. Prototype void     keysave    (KEYTABLE * kt, char * name);
  447. Prototype int     loadkeys    (KEYTABLE * kt, FILE * fi, int * lineno);
  448. Prototype int     savekeys    (KEYTABLE * kt, FILE * fo);
  449. Prototype HASH * findhash    (KEYTABLE * kt, KEYSPEC *ks,       UBYTE *);
  450. Prototype APTR     keyspec2macro    (KEYTABLE * kt,              const UBYTE *);
  451. Prototype int     resethash    (KEYTABLE * kt);
  452. Prototype int     unmapkey    (KEYTABLE * kt, const UBYTE *key);
  453. Prototype int     mapkey     (KEYTABLE * kt, const UBYTE *key, const UBYTE *value, const UBYTE *help);
  454. Prototype int     remhash    (KEYTABLE * kt, KEYSPEC *ks);
  455. Prototype int     addhash    (KEYTABLE * kt, KEYSPEC *ks, const UBYTE *comm, const UBYTE *help);
  456. Prototype void     dealloc_hash    (KEYTABLE * kt);
  457. Prototype KEYTABLE * get_keytable    (char * name);
  458. Prototype KEYTABLE * new_keytable    (char * name, int defaults);
  459. Prototype void         delete_keytable (KEYTABLE * kt, int force);
  460. Prototype void         exit_keytables (void);
  461. Prototype void keyctl (struct IntuiMessage *, int, ULONG);  /* PATCH_NULL [14 Feb 1993] : changed to void */
  462. Prototype struct Library * ConsoleDevice;
  463. Prototype void keyboard_init (void);
  464. Prototype UBYTE* cqtoa (KEYSPEC *ks);
  465. Prototype BOOL get_codequal (const UBYTE *str, KEYSPEC *ks);
  466. Prototype TQUAL iqual2qual (ULONG qual, int blen, char * buf, int code);
  467. Prototype ULONG qual2iqual (TQUAL qual);
  468. Prototype BOOL a2iqual (const UBYTE *str, ULONG *piqual);
  469. Prototype UBYTE *iqual2a (ULONG iqual);
  470. Prototype void init_kb (void);
  471. Prototype UBYTE  CtoA (TCODE c);
  472. Prototype TQUAL CIgnoreQ (TCODE c);
  473. Prototype BOOL IsRawC (KEYSPEC *ks);
  474. Prototype int DeadKeyConvert (struct IntuiMessage * msg, UBYTE * buf, int bufsize, struct KeyMap * keymap);
  475. Prototype long ext_qualifiers;
  476. Prototype int  qualifier (char *);
  477. Prototype void      do_quiet    (void);
  478. Prototype void      do_eval     (void);
  479. Prototype void      do_force    (void);
  480. Prototype void      do_abort    (void);
  481. Prototype void      do_unabort  (void);
  482. Prototype void      do_break    (void);
  483. Prototype void      do_continue (void);
  484. Prototype void      clearcont   (void);
  485. Prototype void      clearbreak  (void);
  486. Prototype void      clearbreaks (void);
  487. Prototype void      do_insertwrite (void);
  488. Prototype void      do_printf     (void);
  489. Prototype void      m_write     (char *);
  490. Prototype void      do_viewmode     (void);
  491. Prototype void      do_simpletabs  (void);
  492. Prototype void      do_activefront (void);
  493. Prototype void      do_sourcebreak (void);
  494. Prototype void      do_windowcyc     (void);
  495. Prototype void      do_fwovr     (void);
  496. Prototype void      do_longline     (void);
  497. Prototype char      MathInfix;
  498. Prototype void      do_unnamedmathfunc(void);
  499. Prototype void      do_namedmathfunc  (void);
  500. Prototype void      do_infixmode        (void);
  501. Prototype void      do_swapV        (void);
  502. Prototype UBYTE * GetArg      (int);
  503. Prototype UBYTE * CommandName (void);
  504. Prototype void clear_record    (void);
  505. Prototype void start_recording    (void);
  506. Prototype void end_recording    (void);
  507. Prototype void replay_record    (void);
  508. Prototype void do_saverecord    (void);
  509. Prototype void add_record    (char * string);
  510. Prototype void    do_setmacro    (void);
  511. Prototype void    do_unsetmacro    (void);
  512. Prototype void    do_setmacrovar    (void);
  513. Prototype void    do_unsetmacrovar(void);
  514. Prototype void    do_retmacro    (void);
  515. Prototype void    do_macrosave    (void);
  516. Prototype void    do_macroload    (void);
  517. Prototype void    SetMacroVar    (char* name, char* value);
  518. Prototype MACRO*getmacro    (char* name);
  519. Prototype int    callmacro    (MACRO*);
  520. Prototype int    nummacroargs    (MACRO*);
  521. Prototype char* getmacroarg    (char* name);
  522. Prototype char* getmacrovar    (char* name);
  523. Prototype void    DelMacros    (void);
  524. Prototype int    SetMacro    (char* name, char* body, int nargs);
  525. Prototype int     savemacros     (FILE *);          /* PATCH_NULL [25 Jan 1993] : proto'd for pack.c */
  526. Prototype int     loadmacros     (FILE *, int *);   /* PATCH_NULL [25 Jan 1993] : proto'd for pack.c */
  527. Prototype int     GetDefMacros     (void);            /* PATCH_NULL [25 Jan 1993] : proto'd for pack.c */
  528. Prototype int init_macros (void);
  529.